/**
 * AI服务工具类
 */
import { API_BASE_URL, AI_ASSISTANT_API, AI_REQUEST_CONFIG, AI_MODEL_CONFIG, STORAGE_KEYS, KIMI_CONFIG } from '../config/ai-config';
import kimiAdapter from './kimi-adapter';

/**
 * 发送聊天请求到AI服务
 * @param {String} query 用户问题
 * @param {Object} options 可选参数
 * @returns {Promise<String>} AI回复内容
 */
export async function sendChatRequest(query, options = {}) {
  const sessionId = getSessionId();
  const userId = getUserId();
  const token = getToken();
  
  // 获取历史消息（如果需要）
  let history = [];
  if (options.includeHistory) {
    history = getRecentChatHistory(5); // 获取最近5条消息作为上下文
  }
  
  // 根据配置选择AI服务提供商
  const provider = options.provider || AI_REQUEST_CONFIG.provider;
  
  try {
    let response;
    
    switch (provider) {
      case 'kimi':
        // 使用Kimi大模型
        response = await useKimiService(query, history, options);
        break;
        
      case 'backend':
        // 使用后端API
        response = await useBackendService(query, userId, sessionId, token, history, options);
        break;
        
      case 'local':
      default:
        // 使用本地模拟回复
        response = getLocalResponse(query);
        break;
    }
    
    return response;
  } catch (error) {
    console.error('AI服务异常', error);
    
    // 显示错误提示
    uni.showToast({
      title: '请求AI服务失败',
      icon: 'none',
      duration: 2000
    });
    
    // 如果配置了使用本地回复，则返回本地回复
    if (AI_REQUEST_CONFIG.useLocalFallback) {
      console.log('使用本地回退逻辑');
      return getLocalResponse(query);
    }
    
    throw error;
  }
}

/**
 * 使用Kimi大模型服务
 * @param {String} query 用户问题
 * @param {Array} history 历史消息
 * @param {Object} options 可选参数
 * @returns {Promise<String>} AI回复内容
 */
async function useKimiService(query, history, options = {}) {
  let retryCount = 0;
  let lastError = null;
  
  // 检查是否配置了API密钥
  if (!kimiAdapter.hasKimiApiKey() && !options.apiKey) {
    throw new Error('未配置Kimi API密钥，请在设置中配置');
  }
  
  // 支持请求重试
  while (retryCount <= AI_REQUEST_CONFIG.retryCount) {
    try {
      console.log(`尝试Kimi请求，第${retryCount + 1}次`);
      
      // 每次重试使用递增的超时时间
      const timeout = options.timeout || 
                     (AI_REQUEST_CONFIG.timeout + (retryCount * 5000));
      
      console.log(`本次请求超时设置: ${timeout}ms`);
      
      const kimiResponse = await kimiAdapter.sendKimiRequest(query, history, {
        apiKey: options.apiKey,
        model: options.model || AI_MODEL_CONFIG.modelName,
        temperature: options.temperature || AI_MODEL_CONFIG.temperature,
        maxTokens: options.maxTokens || AI_MODEL_CONFIG.maxTokens,
        timeout: timeout
      });
      
      if (kimiResponse.success) {
        return kimiResponse.answer;
      } else {
        // 如果是API密钥无效错误，直接抛出不再重试
        if (kimiResponse.errorType === 'INVALID_API_KEY') {
          console.error('Kimi API密钥无效，请更新API密钥');
          throw new Error(kimiResponse.error || 'API密钥无效或已过期，请更新API密钥');
        }
        
        // 如果是超时错误，可以继续重试
        if (kimiResponse.errorType === 'TIMEOUT') {
          console.log('请求超时，准备重试...');
          throw new Error('请求超时');
        }
        
        throw new Error(kimiResponse.error || '请求失败');
      }
    } catch (error) {
      lastError = error;
      retryCount++;
      
      // 如果是API密钥错误，直接抛出不再重试
      if (error.message && error.message.includes('API密钥无效')) {
        console.error('Kimi API密钥验证失败，中止重试');
        break;
      }
      
      // 如果还有重试次数，等待后重试
      if (retryCount <= AI_REQUEST_CONFIG.retryCount) {
        const retryDelay = AI_REQUEST_CONFIG.retryDelay * retryCount; // 递增等待时间
        console.log(`Kimi请求失败，${retryDelay / 1000}秒后重试...`, error);
        await new Promise(resolve => setTimeout(resolve, retryDelay));
      }
    }
  }
  
  // 所有重试都失败了
  console.error('Kimi请求失败，已达到最大重试次数', lastError);
  throw lastError || new Error('请求失败，请检查网络连接或API设置');
}

/**
 * 使用后端API服务
 * @param {String} query 用户问题
 * @param {String} userId 用户ID
 * @param {String} sessionId 会话ID
 * @param {String} token 认证Token
 * @param {Array} history 历史消息
 * @param {Object} options 可选参数
 * @returns {Promise<String>} AI回复内容
 */
async function useBackendService(query, userId, sessionId, token, history, options = {}) {
  const requestData = {
    query,
    userId,
    sessionId,
    timestamp: Date.now(),
    modelConfig: {
      ...AI_MODEL_CONFIG,
      ...options.modelConfig
    }
  };
  
  // 添加历史消息上下文（如果有）
  if (history && history.length > 0) {
    requestData.history = history;
  }
  
  let retryCount = 0;
  let lastError = null;
  
  // 支持请求重试
  while (retryCount <= AI_REQUEST_CONFIG.retryCount) {
    try {
      const response = await uni.request({
        url: `${API_BASE_URL}${AI_ASSISTANT_API.chat}`,
        method: 'POST',
        data: requestData,
        header: {
          'content-type': 'application/json',
          'Authorization': token ? `Bearer ${token}` : ''
        },
        timeout: AI_REQUEST_CONFIG.timeout
      });
      
      // 检查响应状态
      if (response.statusCode === 200 && response.data && response.data.answer) {
        console.log('AI请求成功', response.data);
        return response.data.answer;
      } else {
        throw new Error(response.data?.message || `请求失败，状态码: ${response.statusCode}`);
      }
    } catch (error) {
      lastError = error;
      retryCount++;
      
      // 如果还有重试次数，等待后重试
      if (retryCount <= AI_REQUEST_CONFIG.retryCount) {
        console.log(`后端API请求失败，${retryCount}秒后重试...`, error);
        await new Promise(resolve => setTimeout(resolve, AI_REQUEST_CONFIG.retryDelay));
      }
    }
  }
  
  // 所有重试都失败了
  console.error('后端API请求失败，已达到最大重试次数', lastError);
  throw lastError;
}

/**
 * 发送用户反馈
 * @param {String} messageId 消息ID
 * @param {Boolean} isHelpful 是否有帮助
 * @param {String} feedback 反馈内容
 * @returns {Promise<Object>} 反馈结果
 */
export async function sendFeedback(messageId, isHelpful, feedback = '') {
  try {
    const response = await uni.request({
      url: `${API_BASE_URL}${AI_ASSISTANT_API.feedback}`,
      method: 'POST',
      data: {
        messageId,
        isHelpful,
        feedback,
        userId: getUserId(),
        timestamp: Date.now()
      },
      header: {
        'content-type': 'application/json',
        'Authorization': `Bearer ${getToken()}`
      }
    });
    
    if (response.statusCode === 200) {
      return response.data;
    } else {
      throw new Error(response.data?.message || '反馈提交失败');
    }
  } catch (error) {
    console.error('反馈提交异常', error);
    throw error;
  }
}

/**
 * 获取会话ID
 * @returns {String} 会话ID
 */
export function getSessionId() {
  let sessionId = uni.getStorageSync(STORAGE_KEYS.sessionId);
  if (!sessionId) {
    sessionId = 'session_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    uni.setStorageSync(STORAGE_KEYS.sessionId, sessionId);
  }
  return sessionId;
}

/**
 * 获取用户ID
 * @returns {String} 用户ID
 */
export function getUserId() {
  return uni.getStorageSync(STORAGE_KEYS.userId) || '';
}

/**
 * 获取用户Token
 * @returns {String} 用户Token
 */
export function getToken() {
  return uni.getStorageSync(STORAGE_KEYS.userToken) || '';
}

/**
 * 获取最近的聊天历史
 * @param {Number} count 获取条数
 * @returns {Array} 聊天历史
 */
export function getRecentChatHistory(count = 10) {
  try {
    const historyStr = uni.getStorageSync(STORAGE_KEYS.chatHistory) || '[]';
    const history = JSON.parse(historyStr);
    return history.slice(-count);
  } catch (error) {
    console.error('获取聊天历史失败', error);
    return [];
  }
}

/**
 * 保存聊天消息到历史记录
 * @param {Object} message 聊天消息
 */
export function saveMessageToHistory(message) {
  try {
    const historyStr = uni.getStorageSync(STORAGE_KEYS.chatHistory) || '[]';
    const history = JSON.parse(historyStr);
    
    // 添加消息ID
    if (!message.id) {
      message.id = 'msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    }
    
    // 添加新消息
    history.push(message);
    
    // 如果历史记录过长，可以限制数量
    const maxHistoryLength = 100;
    if (history.length > maxHistoryLength) {
      history.splice(0, history.length - maxHistoryLength);
    }
    
    // 保存回本地存储
    uni.setStorageSync(STORAGE_KEYS.chatHistory, JSON.stringify(history));
  } catch (error) {
    console.error('保存历史记录失败', error);
  }
}

/**
 * 清除聊天历史
 */
export function clearChatHistory() {
  try {
    uni.removeStorageSync(STORAGE_KEYS.chatHistory);
    return true;
  } catch (error) {
    console.error('清除历史记录失败', error);
    return false;
  }
}

/**
 * 保存Kimi API密钥
 * @param {String} apiKey API密钥
 * @returns {Boolean} 是否保存成功
 */
export function saveKimiApiKey(apiKey) {
  return kimiAdapter.saveKimiApiKey(apiKey);
}

/**
 * 检查是否已配置Kimi API密钥
 * @returns {Boolean} 是否已配置
 */
export function hasKimiApiKey() {
  return kimiAdapter.hasKimiApiKey();
}

/**
 * 获取本地模拟回复
 * @param {String} query 用户问题
 * @returns {String} 模拟回复
 */
export function getLocalResponse(query) {
  // 这里实现本地回复逻辑，与之前的getAIResponse类似
  // 可以根据关键词匹配返回预设回复
  
  // 预设回复
  const responses = {
    '如何预约家政服务': '您可以通过以下步骤预约家政服务：\n1. 在首页点击"服务"按钮\n2. 选择您需要的服务类型\n3. 选择合适的服务人员\n4. 选择服务时间并确认\n5. 完成支付即可成功预约\n\n如果您有特殊需求，也可以直接联系客服进行定制服务。',
    '价格': '我们的服务价格根据不同服务类型和时长有所不同：\n\n• 基础保洁：50元/小时\n• 深度保洁：80元/小时\n• 专业保姆：80-120元/小时\n• 育儿嫂：100-150元/小时\n• 养老护理：90-130元/小时\n\n首次使用可享受9折优惠，会员用户还可叠加积分抵扣。'
  };
  
  // 简单的关键词匹配
  for (const key in responses) {
    if (query.includes(key)) {
      return responses[key];
    }
  }
  
  // 默认回复
  return '抱歉，当前网络连接不稳定，无法获取准确回复。请稍后再试，或联系客服获取帮助。';
}

export default {
  sendChatRequest,
  sendFeedback,
  getSessionId,
  getUserId,
  getToken,
  getRecentChatHistory,
  saveMessageToHistory,
  clearChatHistory,
  getLocalResponse,
  saveKimiApiKey,
  hasKimiApiKey
};